home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Extensions / img / imggifmodule.c < prev    next >
Text File  |  1995-12-21  |  40KB  |  1,508 lines
  1. /***********************************************************
  2. Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
  3. Amsterdam, The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24. /*
  25. ** GIF file handling. Jack Jansen, CWI, June 1994.
  26. **
  27. ** Part of this code was taken from giftopnm.c and ppmtogif.c,
  28. ** of which the copyright notices are below.
  29. **
  30. ** giftopnm:
  31. ** +-------------------------------------------------------------------+
  32. ** | Copyright 1990, 1991, 1993, David Koblas.  (koblas@netcom.com)    |
  33. ** |   Permission to use, copy, modify, and distribute this software   |
  34. ** |   and its documentation for any purpose and without fee is hereby |
  35. ** |   granted, provided that the above copyright notice appear in all |
  36. ** |   copies and that both that copyright notice and this permission  |
  37. ** |   notice appear in supporting documentation.  This software is    |
  38. ** |   provided "as is" without express or implied warranty.           |
  39. ** +-------------------------------------------------------------------+
  40. **
  41. ** ppmtogif:
  42. ** Based on GIFENCOD by David Rowley <mgardi@watdscu.waterloo.edu>.A
  43. ** Lempel-Zim compression based on "compress".
  44. **
  45. ** Modified by Marcel Wijkstra <wijkstra@fwi.uva.nl>
  46. **
  47. **
  48. ** Copyright (C) 1989 by Jef Poskanzer.
  49. **
  50. ** Permission to use, copy, modify, and distribute this software and its
  51. ** documentation for any purpose and without fee is hereby granted, provided
  52. ** that the above copyright notice appear in all copies and that both that
  53. ** copyright notice and this permission notice appear in supporting
  54. ** documentation.  This software is provided "as is" without express or
  55. ** implied warranty.
  56. **
  57. ** The Graphics Interchange Format(c) is the Copyright property of
  58. ** CompuServe Incorporated.  GIF(sm) is a Service Mark property of
  59. ** CompuServe Incorporated.
  60. */
  61.  
  62.  
  63. /* Gif objects */
  64.  
  65. #include "Python.h"
  66. #include "import.h"
  67.  
  68. /* XXXX change this to the image formats we support */
  69.  
  70. static PyObject *format_map, *format_map_b2t, *format_choices, *format_xmap;
  71. extern PyObject *getimgformat();        /* Get format by name */
  72. static PyObject *(*makecolormap)();    /* Routine to make a colormap */
  73.  
  74. typedef struct {
  75.     PyObject_HEAD
  76.     PyObject    *dict;        /* Attributes dictionary */
  77.     int    is_reader;    /* TRUE if this is a reader */
  78.     char    *filename;    /* filename of the image file */
  79.     FILE    *filep;
  80.     int    interlaced;    /* TRUE if image is interlaced (for read) */
  81. } gifobject;
  82.  
  83. typedef struct {
  84.     unsigned char    *data;
  85.     int        xpos, ypos, width, height, rowlen;
  86. } GIFwriterdata;
  87.  
  88. static PyObject *errobject;
  89.  
  90. staticforward PyTypeObject Giftype;
  91.  
  92. staticforward int GIFreadheader();    /* Read everything but the data */
  93. staticforward long *GIFreadmap();    /* Read a colormap */
  94. staticforward int GIFskipblock();    /* Skip an extension block */
  95. staticforward int GIFgettransparent();    /* Get transparent extension block */
  96. staticforward int GIFreadimage();    /* Read the image data */
  97. staticforward void GIFcompress();    /* Write and compress */
  98. staticforward void GIFcompress_reinit();/* re-init compress data */
  99.                     /* structures */
  100.  
  101. /*
  102. ** NOTE: The GIF LWZ decompression routines are not safe in parallel
  103. ** programs. They use the ZeroDataBlock variable below to pass a flag around,
  104. ** and use statically allocated tables besides.
  105. */
  106. #define MAX_LWZ_BITS 12
  107. int ZeroDataBlock = 0;
  108.  
  109. #define is_gifobject(v)        ((v)->ob_type == &Giftype)
  110.  
  111. static char doc_pgm[] = "This object reads/writes PGM files\n"
  112.     "The 'width', 'height', 'top', 'left', 'aspect' and 'format'\n"
  113.     "attributes describe the picture,\n"
  114.     "'colormap' has the colormap object for the picture\n"
  115.     "There may be a 'transparent' attribute given in index of the color\n"
  116.     "to be treated as transparent.";
  117.  
  118. /* Routine to easily obtain C data from the dict python data */
  119. int
  120. gifselfattr(self, name, fmt, ptr, wanterr)
  121.     gifobject *self;
  122.     char *name;
  123.     char *fmt;
  124.     void *ptr;
  125.     int wanterr;
  126. {
  127.     PyObject *obj;
  128.     char errbuf[100];
  129.  
  130.     obj = PyDict_GetItemString(self->dict, name);
  131.     if ( obj == NULL ) {
  132.     if ( wanterr ) {
  133.         sprintf(errbuf, "Required attribute '%s' not set", name);
  134.         PyErr_SetString(errobject, errbuf);
  135.         return 0;
  136.     } else {
  137.         PyErr_Clear();
  138.         return 0;
  139.     }
  140.     }
  141.     if ( !PyArg_Parse(obj, fmt, ptr) ) {
  142.     if ( !wanterr )
  143.         PyErr_Clear();
  144.     return 0;
  145.     }
  146.     return 1;
  147. }
  148.  
  149. /* Routine to easily insert integer into dictionary */
  150. gifsetintattr(self, name, value)
  151.     gifobject *self;
  152.     char *name;
  153.     int value;
  154. {
  155.     PyObject *obj;
  156.     int rv;
  157.  
  158.     obj = PyInt_FromLong(value);
  159.     rv = PyDict_SetItemString(self->dict, name, obj);
  160.     Py_DECREF(obj);
  161.     return rv;
  162. }
  163.  
  164. static gifobject *
  165. newgifobject()
  166. {
  167.     gifobject *xp;
  168.     xp = PyObject_NEW(gifobject, &Giftype);
  169.     if (xp == NULL)
  170.         return NULL;
  171.     xp->dict = PyDict_New();
  172.     xp->filename = NULL;
  173.     /* XXXX Initialize other pointers here as well */
  174.     return xp;
  175. }
  176.  
  177. static int
  178. initgifreader(self, name)
  179.     gifobject *self;
  180.     char *name;
  181. {
  182.     char *name_copy;
  183.  
  184.     if( (name_copy=malloc(strlen(name)+1)) == NULL ) {
  185.     PyErr_NoMemory();
  186.     return 0;
  187.     }
  188.     strcpy(name_copy, name);
  189.     self->filename = name_copy;
  190.     self->is_reader = 1;
  191.     if ((self->filep = fopen(self->filename, "rb")) == NULL) {
  192.     PyErr_SetFromErrno(PyExc_IOError);
  193.     return 0;
  194.     }
  195.     if ( !GIFreadheader(self) )
  196.     return 0;
  197.     /* XXXX Open image file, read header, put into dict: */
  198.     PyDict_SetItemString(self->dict, "format", format_map);
  199.     PyDict_SetItemString(self->dict, "format_choices", format_choices);
  200.     if( PyErr_Occurred() )
  201.     return 0;
  202.     return 1;
  203. }
  204.  
  205. static int
  206. GIFreadheader(self)
  207.     gifobject *self;
  208. {
  209.     char buf[6];
  210.     int left, top, width, height, bpp, ncolors, hasmap, bgnd, aspect;
  211.     int ch;
  212.     int atimagestart;
  213.     long *gmap = NULL, *lmap = NULL;
  214.     PyObject *mapobj = NULL;
  215.     unsigned char etype;
  216.     int transparent = -1;
  217.  
  218.     /*
  219.     ** The GIF header looks as follows:
  220.     ** 0-5    "magic number", 'GIF87a' or 'GIF89a'
  221.     ** 6,7    width (little-endian)
  222.     ** 8,9    height
  223.     ** 10       bitsperpixel, colormapflag, interlaceflag
  224.     ** 11    ignored (background color)
  225.     ** 12    aspect ratio
  226.     ** Then a colormap (3 bytes per entry)
  227.     ** Then a number of 'blocks'.
  228.     ** Each block is either an extension (which we ignore) or an image.
  229.     ** An image consists of
  230.     **   0,1    left
  231.     **     2,3    top
  232.     **   4,5    width
  233.     **   6,7    height
  234.     **   8    flag (like in file header)
  235.     **   And then the LZW image data.
  236.     **
  237.     ** There may be more images in the file, but we ignore all but the
  238.     ** first. Actually, we don't read on after the first image.
  239.     */
  240.     if ( fread(buf, 1, 6, self->filep) != 6 ) goto EndOfFile;
  241.     if ( strncmp(buf, "GIF87a", 6) != 0 &&
  242.      strncmp(buf, "GIF89a", 6) != 0 ) {
  243.     PyErr_SetString(errobject, "Not a GIF87 or GIF89 file");
  244.     return 0;
  245.     }
  246.     /* We don't check for EOF each time, only when we start using data */
  247.     ch = getc(self->filep);
  248.     width = ch + (getc(self->filep) << 8);
  249.     ch = getc(self->filep);
  250.     height = ch + (getc(self->filep) << 8);
  251.     ch = getc(self->filep);
  252.     hasmap = (ch & 0x80);
  253.     bpp = (ch & 7) + 1;
  254.     ncolors = 1 << bpp;
  255.     bgnd = getc(self->filep);
  256.     aspect = getc(self->filep);
  257.     if ( feof(self->filep) || ferror(self->filep) ) goto EndOfFile;
  258.  
  259.     if ( hasmap ) {
  260.     if( (gmap = GIFreadmap(self, ncolors)) == NULL )
  261.         goto ErrorExit;
  262.     }
  263.     if ( feof(self->filep) || ferror(self->filep) ) goto EndOfFile;
  264.  
  265.  
  266.     atimagestart = 0;
  267.     do {
  268.     if( (ch = getc(self->filep)) == EOF ) goto EndOfFile;
  269.     switch(ch) {
  270.     case ';':    /* Terminator */
  271.         PyErr_SetString(errobject, "No image found in file");
  272.         return 0;
  273.  
  274.     case '!':    /* Extension */
  275.         etype = (unsigned char)getc(self->filep);    /* Extension type */
  276.         if ( etype == 0xf9 )    /* Transparent extension */
  277.         transparent = GIFgettransparent(self);
  278.         while( GIFskipblock(self) ) ;
  279.         break;
  280.  
  281.     case ',':
  282.         atimagestart = 1;
  283.         break;
  284.     }
  285.     } while ( !atimagestart );
  286.  
  287.     ch = getc(self->filep);
  288.     left = ch + (getc(self->filep) << 8);
  289.     ch = getc(self->filep);
  290.     top = ch + (getc(self->filep) << 8);
  291.     ch = getc(self->filep);
  292.     width = ch + (getc(self->filep) << 8);
  293.     ch = getc(self->filep);
  294.     height = ch + (getc(self->filep) << 8);
  295.     ch = getc(self->filep);
  296.     hasmap = (ch & 0x80);
  297.     self->interlaced = (ch & 0x40);
  298.     if ( hasmap ) { /* Otherwise use values from header */
  299.     bpp = (ch & 7) + 1;
  300.     ncolors = 1 << bpp;
  301.     }
  302.     if ( feof(self->filep) || ferror(self->filep) ) goto EndOfFile;
  303.  
  304.     if ( hasmap ) {
  305.     if( (lmap = GIFreadmap(self, ncolors)) == NULL )
  306.         goto ErrorExit;
  307.     }
  308.     if ( feof(self->filep) || ferror(self->filep) ) goto EndOfFile;
  309.  
  310.     gifsetintattr(self, "width", width);
  311.     gifsetintattr(self, "height", height);
  312.     gifsetintattr(self, "top", top);
  313.     gifsetintattr(self, "left", left);
  314.     gifsetintattr(self, "aspect", aspect);
  315.     if ( transparent > 0 )
  316.     gifsetintattr(self, "transparent", transparent);
  317.     if ( PyErr_Occurred() ) {
  318.     fprintf(stderr, "imggif: unexpected error\n");
  319.     goto ErrorExit;
  320.     }
  321.     if ( lmap ) {
  322.     if ( (mapobj=makecolormap(lmap, ncolors)) == NULL )
  323.         goto ErrorExit;
  324.     } else if ( gmap ) {
  325.     if ( (mapobj=makecolormap(gmap, ncolors)) == NULL )
  326.         goto ErrorExit;
  327.     }
  328.     if ( mapobj )
  329.     PyDict_SetItemString(self->dict, "colormap", mapobj);
  330.  
  331.     if ( lmap )
  332.     free(lmap);
  333.     if ( gmap )
  334.     free(gmap);
  335.     return 1;
  336.     /*
  337.     ** Yes! Labels!
  338.     */
  339.  EndOfFile:
  340.     PyErr_SetString(errobject, "Truncated GIF file");
  341.  ErrorExit:
  342.     if ( lmap )
  343.     free(lmap);
  344.     if ( gmap )
  345.     free(gmap);
  346.     return 0;
  347. }
  348.  
  349. static long *
  350. GIFreadmap(self, ncolors)
  351.     gifobject *self;
  352.     int ncolors;
  353. {
  354.     long *map;
  355.     int r, g, b, i;
  356.  
  357.     if ( (map=(long *)malloc(ncolors*sizeof(long))) == NULL ) {
  358.     PyErr_NoMemory();
  359.     return NULL;
  360.     }
  361.     for(i=0; i<ncolors; i++) {
  362.     r = fgetc(self->filep);
  363.     g = fgetc(self->filep);
  364.     b = fgetc(self->filep);
  365.     map[i] = r | (g<<8) | (b<<16);
  366.     }
  367.     if ( feof(self->filep) || ferror(self->filep) ) {
  368.     PyErr_SetString(errobject, "Truncated GIF file");
  369.     free(map);
  370.     return NULL;
  371.     }
  372.     return map;
  373. }
  374.  
  375. static int
  376. GIFskipblock(self)
  377.     gifobject *self;
  378. {
  379.     int i, count;
  380.  
  381.     if ( (count=fgetc(self->filep)) == EOF )
  382.     return 0;
  383.     for(i=0; i<count; i++)
  384.     (void)fgetc(self->filep);
  385.     return count;
  386. }
  387.  
  388. static int
  389. GIFgettransparent(self)
  390.     gifobject *self;
  391. {
  392.     int count;
  393.     unsigned char value;
  394.  
  395.     if ( (count=fgetc(self->filep)) == EOF || count != 4 )
  396.     return -1;
  397.     (void)fgetc(self->filep);
  398.     (void)fgetc(self->filep);
  399.     (void)fgetc(self->filep);
  400.     value = (unsigned char)fgetc(self->filep);
  401.     return value;
  402. }
  403.  
  404. static int
  405. initgifwriter(self, name)
  406.     gifobject *self;
  407.     char *name;
  408. {
  409.     char *name_copy;
  410.  
  411.     if( (name_copy=malloc(strlen(name)+1)) == NULL ) {
  412.     PyErr_NoMemory();
  413.     return 0;
  414.     }
  415.     strcpy(name_copy, name);
  416.     self->filename = name_copy;
  417.     self->is_reader = 0;
  418.     PyDict_SetItemString(self->dict, "format", format_map);
  419.     PyDict_SetItemString(self->dict, "format_choices", format_choices);
  420.     self->filep = NULL;
  421.     if( PyErr_Occurred())
  422.     return 0;
  423.     return 1;
  424. }
  425.  
  426. /* Gif methods */
  427.  
  428. static void
  429. gif_dealloc(xp)
  430.     gifobject *xp;
  431. {
  432.     Py_XDECREF(xp->dict);
  433.     if( xp->filename )
  434.         free(xp->filename);
  435.     if( xp->filep )
  436.         fclose(xp->filep);
  437.     PyMem_DEL(xp);
  438. }
  439.  
  440. static char doc_read[] = "Read the actual data, returns a string";
  441.  
  442. static PyObject *
  443. gif_read(self, args)
  444.     gifobject *self;
  445.     PyObject *args;
  446. {
  447.         PyObject *fmt;
  448.     PyObject *rv;
  449.     unsigned char *datap;
  450.     int b2t;
  451.     int width, height, rowlen;
  452.     
  453.     if (!PyArg_ParseTuple(args,""))
  454.         return NULL;
  455.     if (!self->is_reader) {
  456.         PyErr_SetString(errobject, "Cannot read() from writer object");
  457.         return NULL;
  458.     }
  459.     /* XXXX Get format (and other args), check, read data, return it */
  460.     if ( !gifselfattr(self, "format", "O", &fmt, 1) ||
  461.          !gifselfattr(self, "width", "i", &width, 1) ||
  462.          !gifselfattr(self, "height", "i", &height, 1) )
  463.         return NULL;
  464.  
  465.     if ( fmt == format_map || fmt == format_xmap ) {
  466.         b2t = 0;
  467.     } else if ( fmt == format_map_b2t ) {
  468.         b2t = 1;
  469.     } else {
  470.         PyErr_SetString(errobject, "Unsupported image format");
  471.         return NULL;
  472.     }
  473.  
  474.     if ( fmt == format_xmap )
  475.         rowlen = width;
  476.     else
  477.         rowlen = (width+3) & ~3;    /* SGI images 32bit aligned */
  478.     if( (rv=PyString_FromStringAndSize(NULL, rowlen*height)) == NULL )
  479.         return NULL;
  480.     datap = (unsigned char *)PyString_AsString(rv);
  481.     if ( b2t ) {
  482.         datap = datap + rowlen*(height-1);
  483.         rowlen = -rowlen;
  484.     }
  485.  
  486.     if (GIFreadimage(self, datap, width, height, rowlen,
  487.              self->interlaced) == 0) {
  488.         Py_DECREF(rv);
  489.         return NULL;
  490.     }
  491.     return rv;
  492. }
  493.  
  494. /*
  495. ** LWZ reader routines stolen from giftopnm.c
  496. */
  497.  
  498. static int
  499. LWZGetDataBlock(fd, buf)
  500. FILE           *fd;
  501. unsigned char  *buf;
  502. {
  503.        unsigned char   count;
  504.  
  505.        if ( feof(fd) ) goto EndOfFile;
  506.        count=(unsigned char)fgetc(fd);
  507.  
  508.        ZeroDataBlock = count == 0;
  509.  
  510.        if ((count != 0) && (fread(buf, 1, count, fd) != count))
  511.        goto EndOfFile;
  512.  
  513.        return count;
  514.    EndOfFile:
  515.        PyErr_SetString(errobject, "Truncated GIF file");
  516.        return -1;
  517. }
  518.  
  519. static int
  520. LWZGetCode(fd, code_size, flag)
  521. FILE   *fd;
  522. int    code_size;
  523. int    flag;
  524. {
  525.        static unsigned char    buf[280];
  526.        static int              curbit, lastbit, done, last_byte;
  527.        int                     i, j, ret;
  528.        int                     count;
  529.  
  530.        if (flag) {
  531.                curbit = 0;
  532.                lastbit = 0;
  533.                done = 0;
  534.                return 0;
  535.        }
  536.  
  537.        if ( (curbit+code_size) >= lastbit) {
  538.                if (done) {
  539.                        if (curbit >= lastbit)
  540.                                PyErr_SetString(errobject,
  541.                       "ran off the end of my bits" );
  542.                        return -1;
  543.                }
  544.                buf[0] = buf[last_byte-2];
  545.                buf[1] = buf[last_byte-1];
  546.  
  547.                if ((count = LWZGetDataBlock(fd, &buf[2])) == 0)
  548.                        done = 1;
  549.            if ( count < 0 ) return -1;
  550.  
  551.                last_byte = 2 + (unsigned char)count;
  552.                curbit = (curbit - lastbit) + 16;
  553.                lastbit = (2+(unsigned char)count)*8 ;
  554.        }
  555.  
  556.        ret = 0;
  557.        for (i = curbit, j = 0; j < code_size; ++i, ++j)
  558.                ret |= ((buf[ i / 8 ] & (1 << (i % 8))) != 0) << j;
  559.  
  560.        curbit += code_size;
  561.  
  562.        return ret;
  563. }
  564.  
  565. static int
  566. LWZReadByte(fd, flag, input_code_size)
  567. FILE   *fd;
  568. int    flag;
  569. int    input_code_size;
  570. {
  571.        static int      fresh = 0;
  572.        int             code, incode;
  573.        static int      code_size, set_code_size;
  574.        static int      max_code, max_code_size;
  575.        static int      firstcode, oldcode;
  576.        static int      clear_code, end_code;
  577.        static int      table[2][(1<< MAX_LWZ_BITS)];
  578.        static int      stack[(1<<(MAX_LWZ_BITS))*2], *sp;
  579.        register int    i;
  580.  
  581.        if (flag) {
  582.                set_code_size = input_code_size;
  583.                code_size = set_code_size+1;
  584.                clear_code = 1 << set_code_size ;
  585.                end_code = clear_code + 1;
  586.                max_code_size = 2*clear_code;
  587.                max_code = clear_code+2;
  588.  
  589.                if ( LWZGetCode(fd, 0, 1) < 0 )
  590.            return -1;
  591.                
  592.                fresh = 1;
  593.  
  594.                for (i = 0; i < clear_code; ++i) {
  595.                        table[0][i] = 0;
  596.                        table[1][i] = i;
  597.                }
  598.                for (; i < (1<<MAX_LWZ_BITS); ++i)
  599.                        table[0][i] = table[1][0] = 0;
  600.  
  601.                sp = stack;
  602.  
  603.                return 0;
  604.        } else if (fresh) {
  605.                fresh = 0;
  606.                do {
  607.                        firstcode = oldcode =
  608.                                LWZGetCode(fd, code_size, 0);
  609.                if ( oldcode < 0 ) return -1;
  610.                } while (firstcode == clear_code);
  611.                return firstcode;
  612.        }
  613.  
  614.        if (sp > stack)
  615.                return *--sp;
  616.  
  617.        while ((code = LWZGetCode(fd, code_size, 0)) >= 0) {
  618.                if (code == clear_code) {
  619.                        for (i = 0; i < clear_code; ++i) {
  620.                                table[0][i] = 0;
  621.                                table[1][i] = i;
  622.                        }
  623.                        for (; i < (1<<MAX_LWZ_BITS); ++i)
  624.                                table[0][i] = table[1][i] = 0;
  625.                        code_size = set_code_size+1;
  626.                        max_code_size = 2*clear_code;
  627.                        max_code = clear_code+2;
  628.                        sp = stack;
  629.                        firstcode = oldcode =
  630.                                        LWZGetCode(fd, code_size, 0);
  631.                        return firstcode;
  632.                } else if (code == end_code) {
  633.                        int             count;
  634.                        unsigned char   buf[260];
  635.  
  636.                        if (ZeroDataBlock)
  637.                                return -2;
  638.  
  639.                        while ((count = LWZGetDataBlock(fd, buf)) > 0)
  640.                                ;
  641.  
  642.                        if (count != 0)
  643.                                PyErr_SetString(errobject,
  644.                       "missing EOD in data stream");
  645.                        return -2;
  646.                }
  647.  
  648.                incode = code;
  649.  
  650.                if (code >= max_code) {
  651.                        *sp++ = firstcode;
  652.                        code = oldcode;
  653.                }
  654.  
  655.                while (code >= clear_code) {
  656.                        *sp++ = table[1][code];
  657.                        if (code == table[0][code]) {
  658.                                PyErr_SetString(errobject,
  659.                       "circular table entry BIG ERROR");
  660.                    return -1;
  661.                }
  662.                        code = table[0][code];
  663.                }
  664.  
  665.                *sp++ = firstcode = table[1][code];
  666.  
  667.                if ((code = max_code) <(1<<MAX_LWZ_BITS)) {
  668.                        table[0][code] = oldcode;
  669.                        table[1][code] = firstcode;
  670.                        ++max_code;
  671.                        if ((max_code >= max_code_size) &&
  672.                                (max_code_size < (1<<MAX_LWZ_BITS))) {
  673.                                max_code_size *= 2;
  674.                                ++code_size;
  675.                        }
  676.                }
  677.  
  678.                oldcode = incode;
  679.  
  680.                if (sp > stack)
  681.                        return *--sp;
  682.        }
  683.        return code;
  684. }
  685.  
  686. static int
  687. GIFreadimage(self, datap, width, height, rowlen, interlace)
  688.     gifobject *self;
  689.     char *datap;
  690.     int width, height, rowlen;
  691.     int interlace;
  692. {
  693.     int ch, v, xpos=0, ypos=0, pass=0;
  694.  
  695.     if ( (ch=getc(self->filep)) == EOF ) {
  696.     PyErr_SetString(errobject, "Truncated GIF file");
  697.     return 0;
  698.     }
  699.     if (LWZReadByte(self->filep, 1, ch) < 0 )
  700.     return 0;
  701.     while ((v=LWZReadByte(self->filep, 0, ch)) >= 0 ) {
  702.     datap[ypos*rowlen+xpos] = v;
  703.     xpos++;
  704.     if ( xpos == width ) {
  705.         while(xpos < rowlen) {
  706.         datap[ypos*rowlen+xpos] = 0;
  707.         xpos++;
  708.         }
  709.         xpos = 0;
  710.         if( interlace ) {
  711.         switch(pass) {
  712.         case 0:
  713.         case 1:
  714.             ypos += 8; break;
  715.         case 2:
  716.             ypos += 4; break;
  717.         case 3:
  718.             ypos += 2; break;
  719.         }
  720.         
  721.         if (ypos >= height) {
  722.             pass++;
  723.             switch (pass) {
  724.             case 1:
  725.             ypos = 4; break;
  726.             case 2:
  727.             ypos = 2; break;
  728.             case 3:
  729.             ypos = 1; break;
  730.             default:
  731.             return 1; /* all done */
  732.             }
  733.         }
  734.         } else {
  735.         ypos++;
  736.         }
  737.     }
  738.     if (ypos >= height)
  739.         return 1; /* all done */
  740.     }
  741.     return 0;
  742. }
  743.  
  744. static void
  745. GIFputword( w, fp)
  746.     int w;
  747.     FILE* fp;
  748. {
  749.     fputc( w & 0xff, fp );
  750.     fputc( (w>>8) & 0xff, fp );
  751. }
  752.  
  753. GIFgetcompressbyte(dp)
  754.     GIFwriterdata *dp;
  755. {
  756.     int rv;
  757.     
  758.     if ( dp->ypos >= dp->height )
  759.     return EOF;
  760.     rv = dp->data[dp->ypos*dp->rowlen + dp->xpos];
  761.     dp->xpos++;
  762.     if ( dp->xpos >= dp->width ) {
  763.     dp->xpos = 0;
  764.     dp->ypos++;
  765.     }
  766.     return rv;
  767. }
  768.  
  769. static char doc_write[] = "Write (string) data to the GIF file";
  770.  
  771. static PyObject *
  772. gif_write(self, args)
  773.     gifobject *self;
  774.     PyObject *args;
  775. {
  776.         char *data;
  777.     int datalen;
  778.     int w, h, rowlen;
  779.     PyObject *fmt, *colormap, *colormapstring;
  780.     long *mapdata;
  781.     GIFwriterdata dstr;
  782.     int i;
  783.     int ch;
  784.     int transparent;
  785.     FILE *filep;
  786.     
  787.     if (!PyArg_ParseTuple(args, "s#", &data, &datalen))
  788.         return NULL;
  789.     if (self->is_reader) {
  790.         PyErr_SetString(errobject, "Cannot write() to reader object");
  791.         return NULL;
  792.     }
  793.     /* XXXX Get args from self->dict and write the data */
  794.     if ( !gifselfattr(self, "width", "i", &w, 1) ||
  795.          !gifselfattr(self, "height", "i", &h, 1) ||
  796.          !gifselfattr(self, "format", "O", &fmt, 1) ||
  797.          !gifselfattr(self, "colormap", "O", &colormap, 1) )
  798.         return NULL;
  799.  
  800.     if ( fmt == format_xmap )
  801.         rowlen = w;
  802.     else
  803.         rowlen = (w+3) & ~3;    /* SGI formats are 32-bit aligned */
  804.  
  805.     if ( fmt != format_map && fmt != format_xmap &&
  806.          fmt != format_map_b2t ) {
  807.         PyErr_SetString(errobject, "Unsupported image format");
  808.         return NULL;
  809.     }
  810.     if( rowlen*h != datalen ) {
  811.         PyErr_SetString(errobject, "Incorrect datasize");
  812.         return NULL;
  813.     }
  814.     
  815.     if ( colormap == Py_None ) {
  816.         mapdata = NULL;
  817.         colormapstring = NULL;
  818.     } else {
  819.         if( (colormapstring=PyObject_GetAttrString(colormap,
  820.                     "_map_as_string")) == NULL ) {
  821.         PyErr_SetString(errobject, "'colormap' attribute is no colormap");
  822.         return NULL;
  823.         }
  824.         mapdata = (long *)PyString_AsString(colormapstring);
  825.     }
  826.     
  827.     if ( fmt == format_map_b2t ) {
  828.         data = data + rowlen*(h-1);
  829.         rowlen = -rowlen;
  830.     }
  831.  
  832.     /*
  833.     ** Open the file.
  834.     */
  835.     if ((filep = fopen(self->filename, "wb")) == NULL) {
  836.         PyErr_SetFromErrno(PyExc_IOError);
  837.         Py_XDECREF(colormapstring);
  838.         return NULL;
  839.     }
  840. #ifdef macintosh
  841.     setfiletype(self->filename, '????', 'GIF ');
  842. #endif
  843.     /*
  844.     ** Write the header.
  845.     */
  846.     fwrite("GIF87a", 1, 6, filep);
  847.     GIFputword(w, filep);
  848.     GIFputword(h, filep);
  849.     /* XXXX This might be incorrect */
  850.     ch = 0x67;    /* XXXX Correct? bits per pixel -1 */
  851.     if ( mapdata )
  852.         ch |= 0x80;
  853.     fputc(ch, filep);
  854.     fputc(0, filep);
  855.     fputc(0, filep);
  856.     if ( mapdata ) {
  857.         for(i=0; i<256; i++) {
  858.         ch = mapdata[i] & 0xff;
  859.         fputc(ch, filep);
  860.         ch = (mapdata[i]>>8) & 0xff;
  861.         fputc(ch, filep);
  862.         ch = (mapdata[i]>>16) & 0xff;
  863.         fputc(ch, filep);
  864.         }
  865.         /* Now we can free the map stuff */
  866.         Py_DECREF(colormapstring);
  867.     }
  868.  
  869.     /* Write the (optional) transparency extension */
  870.     if ( gifselfattr(self, "transparent", "i", &transparent, 0) ) {
  871.         fputc('!', filep);
  872.         fputc(0xf9, filep);
  873.         fputc(4, filep);
  874.         fputc(1, filep);
  875.         fputc(0, filep);
  876.         fputc(0, filep);
  877.         fputc((unsigned char)transparent, filep);
  878.         fputc(0, filep);
  879.     }
  880.     
  881.     /* Now the image */
  882.     fputc( ',', filep);
  883.     GIFputword(0, filep);
  884.     GIFputword(0, filep);
  885.     GIFputword(w, filep);
  886.     GIFputword(h, filep);
  887.     fputc(0, filep);        /* We don't interlace */
  888.     fputc(8, filep);        /* Initial code size */
  889.     /*
  890.     ** Setup struct to pass writer args to compressor
  891.     */
  892.     dstr.data = (unsigned char *)data;
  893.     dstr.xpos = 0;
  894.     dstr.ypos = 0;
  895.     dstr.width = w;
  896.     dstr.height = h;
  897.     dstr.rowlen = rowlen;
  898.     GIFcompress(9, filep, &dstr);
  899.     fflush(filep);
  900.     if ( ferror(filep) ) {
  901.         PyErr_SetFromErrno(PyExc_IOError);
  902.         fclose(filep);
  903.         return NULL;
  904.     }
  905.     /*
  906.     ** Trailer
  907.     */
  908.     fputc(0, filep);
  909.     fputc(';', filep);
  910.     if (fclose(filep) != 0) {
  911.         PyErr_SetFromErrno(PyExc_IOError);
  912.         return NULL;
  913.     }
  914.     Py_INCREF(Py_None);
  915.     return Py_None;
  916. }
  917.  
  918. static struct PyMethodDef gif_methods[] = {
  919.     {"read",    (PyCFunction)gif_read,    1,    doc_read},
  920.     {"write",    (PyCFunction)gif_write,    1,    doc_write},
  921.     {NULL,        NULL}        /* sentinel */
  922. };
  923.  
  924. static PyObject *
  925. gif_getattr(xp, name)
  926.     gifobject *xp;
  927.     char *name;
  928. {
  929.         PyObject *v;
  930.     
  931.     if (xp->dict != NULL) {
  932.             if ( strcmp(name, "__dict__") == 0 ) {
  933.                 Py_INCREF(xp->dict);
  934.             return xp->dict;
  935.         }
  936.                if ( strcmp(name, "__doc__") == 0 ) {
  937.                 return PyString_FromString(doc_pgm);
  938.         }
  939.         v = PyDict_GetItemString(xp->dict, name);
  940.         if (v != NULL) {
  941.             Py_INCREF(v);
  942.             return v;
  943.         }
  944.     }
  945.     return Py_FindMethod(gif_methods, (PyObject *)xp, name);
  946. }
  947.  
  948. static int
  949. gif_setattr(xp, name, v)
  950.     gifobject *xp;
  951.     char *name;
  952.     PyObject *v;
  953. {
  954.     if (xp->dict == NULL) {
  955.         xp->dict = PyDict_New();
  956.         if (xp->dict == NULL)
  957.             return -1;
  958.     }
  959.     if (v == NULL) {
  960.         int rv = PyDict_DelItemString(xp->dict, name);
  961.         if (rv < 0)
  962.             PyErr_SetString(PyExc_AttributeError,
  963.                     "delete non-existing imggif attribute");
  964.         return rv;
  965.     }
  966.     else
  967.         return PyDict_SetItemString(xp->dict, name, v);
  968. }
  969.  
  970. static PyTypeObject Giftype = {
  971.     PyObject_HEAD_INIT(&PyType_Type)
  972.     0,            /*ob_size*/
  973.     "imggif",        /*tp_name*/
  974.     sizeof(gifobject),    /*tp_basicsize*/
  975.     0,            /*tp_itemsize*/
  976.     /* methods */
  977.     (destructor)gif_dealloc, /*tp_dealloc*/
  978.     0,            /*tp_print*/
  979.     (getattrfunc)gif_getattr, /*tp_getattr*/
  980.     (setattrfunc)gif_setattr, /*tp_setattr*/
  981.     0,            /*tp_compare*/
  982.     0,            /*tp_repr*/
  983.     0,            /*tp_as_number*/
  984.     0,            /*tp_as_sequence*/
  985.     0,            /*tp_as_mapping*/
  986.     0,            /*tp_hash*/
  987. };
  988.  
  989. static char doc_newreader[] =
  990.     "Return an object that reads the GIF file passed as argument";
  991.  
  992. static PyObject *
  993. gif_newreader(self, args)
  994.     PyObject *self;
  995.     PyObject *args;
  996. {
  997.         char *filename;
  998.     gifobject *obj;
  999.     
  1000.     if (!PyArg_ParseTuple(args, "s", &filename))
  1001.         return NULL;
  1002.     if ((obj = newgifobject()) == NULL)
  1003.         return NULL;
  1004.     if ( !initgifreader(obj, filename) ) {
  1005.         gif_dealloc(obj);
  1006.         return NULL;
  1007.     }
  1008.     return (PyObject *)obj;
  1009. }
  1010.  
  1011. static char doc_newwriter[] =
  1012.     "Return an object that writes the GIF file passed as argument";
  1013.  
  1014. static PyObject *
  1015. gif_newwriter(self, args)
  1016.     PyObject *self;
  1017.     PyObject *args;
  1018. {
  1019.         char *filename;
  1020.     gifobject *obj;
  1021.     
  1022.     if (!PyArg_ParseTuple(args, "s", &filename))
  1023.         return NULL;
  1024.     if ((obj = newgifobject()) == NULL)
  1025.         return NULL;
  1026.     if ( !initgifwriter(obj, filename) ) {
  1027.         gif_dealloc(obj);
  1028.         return NULL;
  1029.     }
  1030.     return (PyObject *)obj;
  1031. }
  1032.  
  1033.  
  1034. /* List of functions defined in the module */
  1035.  
  1036. static struct PyMethodDef gif_module_methods[] = {
  1037.     {"reader",    gif_newreader,    1,    doc_newreader},
  1038.     {"writer",    gif_newwriter,    1,    doc_newwriter},
  1039.     {NULL,        NULL}        /* sentinel */
  1040. };
  1041.  
  1042.  
  1043. /* Initialization function for the module (*must* be called initimggif) */
  1044. static char doc_imggif[] =
  1045.   "Module that reads and writes images to GIF files";
  1046.  
  1047.  
  1048. void
  1049. initimggif()
  1050. {
  1051.     PyObject *m, *d, *formatmodule, *formatdict, *o;
  1052.  
  1053.     /* Create the module and add the functions */
  1054.     m = Py_InitModule("imggif", gif_module_methods);
  1055.  
  1056.     /* Add some symbolic constants to the module */
  1057.     d = PyModule_GetDict(m);
  1058.     errobject = PyString_FromString("imggif.error");
  1059.     PyDict_SetItemString(d, "error", errobject);
  1060.     o = PyString_FromString(doc_imggif);
  1061.     PyDict_SetItemString(d, "__doc__", o);
  1062.  
  1063.     /* Get supported formats */
  1064.     if ((formatmodule = PyImport_ImportModule("imgformat")) == NULL)
  1065.         Py_FatalError("imggif depends on imgformat");
  1066.     if ((formatdict = PyModule_GetDict(formatmodule)) == NULL)
  1067.         Py_FatalError("imgformat has no dict");
  1068.  
  1069.     format_map = PyDict_GetItemString(formatdict,"colormap");
  1070.     format_xmap = PyDict_GetItemString(formatdict,"xcolormap");
  1071.     format_map_b2t = PyDict_GetItemString(formatdict,"colormap_b2t");
  1072.     format_choices = Py_BuildValue("(OOO)", format_map, format_xmap,
  1073.                  format_map_b2t);
  1074.  
  1075.     /* Get pointer to colormap-creation routine. NOTE: this is a hack */
  1076.     if ((formatmodule = PyImport_ImportModule("imgcolormap")) == NULL)
  1077.         Py_FatalError("imggif depends on imgcolormap");
  1078.     if ((formatdict = PyModule_GetDict(formatmodule)) == NULL)
  1079.         Py_FatalError("imgcolormap has no dict");
  1080.  
  1081.     o = PyDict_GetItemString(formatdict, "_C_newmap");
  1082.     (void)PyArg_Parse(o, "l", (long *)&makecolormap);
  1083.     
  1084.  
  1085.     /* Check for errors */
  1086.     if (PyErr_Occurred())
  1087.         Py_FatalError("can't initialize module imggif");
  1088. }
  1089.  
  1090. /***************************************************************************
  1091.  *
  1092.  *  GIFCOMPR.C       - GIF Image compression routines
  1093.  *
  1094.  *  Lempel-Ziv compression based on 'compress'.  GIF modifications by
  1095.  *  David Rowley (mgardi@watdcsu.waterloo.edu)
  1096.  *
  1097.  ***************************************************************************/
  1098.  
  1099. /*
  1100.  * General DEFINEs
  1101.  */
  1102.  
  1103. #define BITS    12
  1104.  
  1105. #define HSIZE  5003            /* 80% occupancy */
  1106.  
  1107. #ifdef NO_UCHAR
  1108.  typedef char   char_type;
  1109. #else /*NO_UCHAR*/
  1110.  typedef        unsigned char   char_type;
  1111. #endif /*NO_UCHAR*/
  1112.  
  1113. /*
  1114.  *
  1115.  * GIF Image compression - modified 'compress'
  1116.  *
  1117.  * Based on: compress.c - File compression ala IEEE Computer, June 1984.
  1118.  *
  1119.  * By Authors:  Spencer W. Thomas       (decvax!harpo!utah-cs!utah-gr!thomas)
  1120.  *              Jim McKie               (decvax!mcvax!jim)
  1121.  *              Steve Davies            (decvax!vax135!petsd!peora!srd)
  1122.  *              Ken Turkowski           (decvax!decwrl!turtlevax!ken)
  1123.  *              James A. Woods          (decvax!ihnp4!ames!jaw)
  1124.  *              Joe Orost               (decvax!vax135!petsd!joe)
  1125.  *
  1126.  */
  1127. /*
  1128.  * a code_int must be able to hold 2**BITS values of type int, and also -1
  1129.  */
  1130. typedef int             code_int;
  1131.  
  1132. #ifdef SIGNED_COMPARE_SLOW
  1133. typedef unsigned long int count_int;
  1134. typedef unsigned short int count_short;
  1135. #else /*SIGNED_COMPARE_SLOW*/
  1136. typedef long int          count_int;
  1137. #endif /*SIGNED_COMPARE_SLOW*/
  1138.  
  1139. #include <ctype.h>
  1140.  
  1141. #define ARGVAL() (*++(*argv) || (--argc && *++argv))
  1142.  
  1143. staticforward void output();
  1144. staticforward void cl_block();
  1145. staticforward void cl_hash();
  1146. staticforward void char_init();
  1147. staticforward void char_out();
  1148. staticforward void flush_char();
  1149.  
  1150. static int n_bits;                        /* number of bits/code */
  1151. static int maxbits = BITS;                /* user settable max # bits/code */
  1152. static code_int maxcode;                  /* maximum code, given n_bits */
  1153. static code_int maxmaxcode = (code_int)1 << BITS; /* should NEVER generate this code */
  1154. #ifdef COMPATIBLE               /* But wrong! */
  1155. # define MAXCODE(n_bits)        ((code_int) 1 << (n_bits) - 1)
  1156. #else /*COMPATIBLE*/
  1157. # define MAXCODE(n_bits)        (((code_int) 1 << (n_bits)) - 1)
  1158. #endif /*COMPATIBLE*/
  1159.  
  1160. static count_int htab [HSIZE];
  1161. static unsigned short codetab [HSIZE];
  1162. #define HashTabOf(i)       htab[i]
  1163. #define CodeTabOf(i)    codetab[i]
  1164.  
  1165. static code_int hsize = HSIZE;                 /* for dynamic table sizing */
  1166.  
  1167. /*
  1168.  * To save much memory, we overlay the table used by compress() with those
  1169.  * used by decompress().  The tab_prefix table is the same size and type
  1170.  * as the codetab.  The tab_suffix table needs 2**BITS characters.  We
  1171.  * get this from the beginning of htab.  The output stack uses the rest
  1172.  * of htab, and contains characters.  There is plenty of room for any
  1173.  * possible stack (stack used to be 8000 characters).
  1174.  */
  1175.  
  1176. #define tab_prefixof(i) CodeTabOf(i)
  1177. #define tab_suffixof(i)        ((char_type*)(htab))[i]
  1178. #define de_stack               ((char_type*)&tab_suffixof((code_int)1<<BITS))
  1179.  
  1180. static code_int free_ent = 0;                  /* first unused entry */
  1181.  
  1182. /*
  1183.  * block compression parameters -- after all codes are used up,
  1184.  * and compression rate changes, start over.
  1185.  */
  1186. static int clear_flg = 0;
  1187.  
  1188. static long int in_count = 1;            /* length of input */
  1189. static long int out_count = 0;           /* # of codes output (for debugging) */
  1190.  
  1191. /*
  1192.  * compress stdin to stdout
  1193.  *
  1194.  * Algorithm:  use open addressing double hashing (no chaining) on the
  1195.  * prefix code / next character combination.  We do a variant of Knuth's
  1196.  * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
  1197.  * secondary probe.  Here, the modular division first probe is gives way
  1198.  * to a faster exclusive-or manipulation.  Also do block compression with
  1199.  * an adaptive reset, whereby the code table is cleared when the compression
  1200.  * ratio decreases, but after the table fills.  The variable-length output
  1201.  * codes are re-sized at this point, and a special CLEAR code is generated
  1202.  * for the decompressor.  Late addition:  construct the table according to
  1203.  * file size for noticeable speed improvement on small files.  Please direct
  1204.  * questions about this implementation to ames!jaw.
  1205.  */
  1206.  
  1207. static int g_init_bits;
  1208. static FILE* g_outfile;
  1209.  
  1210. static int ClearCode;
  1211. static int EOFCode;
  1212.  
  1213. static void
  1214. GIFcompress( init_bits, outfile, gwdp)
  1215. int init_bits;
  1216. FILE* outfile;
  1217. GIFwriterdata *gwdp;
  1218. {
  1219.     register long fcode;
  1220.     register code_int i /* = 0 */;
  1221.     register int c;
  1222.     register code_int ent;
  1223.     register code_int disp;
  1224.     register code_int hsize_reg;
  1225.     register int hshift;
  1226.  
  1227.     GIFcompress_reinit();
  1228.      /*
  1229.      * Set up the globals:  g_init_bits - initial number of bits
  1230.      *                      g_outfile   - pointer to output file
  1231.      */
  1232.     g_init_bits = init_bits;
  1233.     g_outfile = outfile;
  1234.  
  1235.     /*
  1236.      * Set up the necessary values
  1237.      */
  1238.     out_count = 0;
  1239.     clear_flg = 0;
  1240.     in_count = 1;
  1241.     maxcode = MAXCODE(n_bits = g_init_bits);
  1242.  
  1243.     ClearCode = (1 << (init_bits - 1));
  1244.     EOFCode = ClearCode + 1;
  1245.     free_ent = ClearCode + 2;
  1246.  
  1247.     char_init();
  1248.  
  1249.     ent = GIFgetcompressbyte(gwdp);
  1250.  
  1251.     hshift = 0;
  1252.     for ( fcode = (long) hsize;  fcode < 65536L; fcode *= 2L )
  1253.         ++hshift;
  1254.     hshift = 8 - hshift;                /* set hash code range bound */
  1255.  
  1256.     hsize_reg = hsize;
  1257.     cl_hash( (count_int) hsize_reg);            /* clear hash table */
  1258.  
  1259.     output( (code_int)ClearCode );
  1260. #ifdef SIGNED_COMPARE_SLOW
  1261.     while ( (c = GIFgetcompressbyte( gwdp )) != (unsigned) EOF ) {
  1262. #else /*SIGNED_COMPARE_SLOW*/
  1263.     while ( (c = GIFgetcompressbyte( gwdp )) != EOF ) {  /* } */
  1264. #endif /*SIGNED_COMPARE_SLOW*/
  1265.         ++in_count;
  1266.  
  1267.         fcode = (long) (((long) c << maxbits) + ent);
  1268.         i = (((code_int)c << hshift) ^ ent);    /* xor hashing */
  1269.         if ( HashTabOf (i) == fcode ) {
  1270.             ent = CodeTabOf (i);
  1271.             continue;
  1272.         } else if ( (long)HashTabOf (i) < 0 )      /* empty slot */
  1273.             goto nomatch;
  1274.         disp = hsize_reg - i;           /* secondary hash (after G. Knott) */
  1275.         if ( i == 0 )
  1276.             disp = 1;
  1277. probe:
  1278.         if ( (i -= disp) < 0 )
  1279.             i += hsize_reg;
  1280.         if ( HashTabOf (i) == fcode ) {
  1281.             ent = CodeTabOf (i);
  1282.             continue;
  1283.         }
  1284.         if ( (long)HashTabOf (i) > 0 )
  1285.             goto probe;
  1286. nomatch:
  1287.         output ( (code_int) ent );
  1288.         ++out_count;
  1289.         ent = c;
  1290. #ifdef SIGNED_COMPARE_SLOW
  1291.         if ( (unsigned) free_ent < (unsigned) maxmaxcode) {
  1292. #else /*SIGNED_COMPARE_SLOW*/
  1293.         if ( free_ent < maxmaxcode ) {  /* } */
  1294. #endif /*SIGNED_COMPARE_SLOW*/
  1295.             CodeTabOf (i) = free_ent++; /* code -> hashtable */
  1296.             HashTabOf (i) = fcode;
  1297.         } else
  1298.                 cl_block();
  1299.     }
  1300.     /*
  1301.      * Put out the final code.
  1302.      */
  1303.     output( (code_int)ent );
  1304.     ++out_count;
  1305.     output( (code_int) EOFCode );
  1306. }
  1307.  
  1308. /*****************************************************************
  1309.  * TAG( output )
  1310.  *
  1311.  * Output the given code.
  1312.  * Inputs:
  1313.  *      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
  1314.  *              that n_bits =< (long)wordsize - 1.
  1315.  * Outputs:
  1316.  *      Outputs code to the file.
  1317.  * Assumptions:
  1318.  *      Chars are 8 bits long.
  1319.  * Algorithm:
  1320.  *      Maintain a BITS character long buffer (so that 8 codes will
  1321.  * fit in it exactly).  Use the VAX insv instruction to insert each
  1322.  * code in turn.  When the buffer fills up empty it and start over.
  1323.  */
  1324.  
  1325. static unsigned long cur_accum = 0;
  1326. static int cur_bits = 0;
  1327.  
  1328. static unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
  1329.                                   0x001F, 0x003F, 0x007F, 0x00FF,
  1330.                                   0x01FF, 0x03FF, 0x07FF, 0x0FFF,
  1331.                                   0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
  1332.  
  1333. static void
  1334. output( code )
  1335. code_int  code;
  1336. {
  1337.     cur_accum &= masks[ cur_bits ];
  1338.  
  1339.     if( cur_bits > 0 )
  1340.         cur_accum |= ((long)code << cur_bits);
  1341.     else
  1342.         cur_accum = code;
  1343.  
  1344.     cur_bits += n_bits;
  1345.  
  1346.     while( cur_bits >= 8 ) {
  1347.         char_out( (unsigned int)(cur_accum & 0xff) );
  1348.         cur_accum >>= 8;
  1349.         cur_bits -= 8;
  1350.     }
  1351.  
  1352.     /*
  1353.      * If the next entry is going to be too big for the code size,
  1354.      * then increase it, if possible.
  1355.      */
  1356.    if ( free_ent > maxcode || clear_flg ) {
  1357.  
  1358.             if( clear_flg ) {
  1359.  
  1360.                 maxcode = MAXCODE (n_bits = g_init_bits);
  1361.                 clear_flg = 0;
  1362.  
  1363.             } else {
  1364.  
  1365.                 ++n_bits;
  1366.                 if ( n_bits == maxbits )
  1367.                     maxcode = maxmaxcode;
  1368.                 else
  1369.                     maxcode = MAXCODE(n_bits);
  1370.             }
  1371.         }
  1372.  
  1373.     if( code == EOFCode ) {
  1374.         /*
  1375.          * At EOF, write the rest of the buffer.
  1376.          */
  1377.         while( cur_bits > 0 ) {
  1378.                 char_out( (unsigned int)(cur_accum & 0xff) );
  1379.                 cur_accum >>= 8;
  1380.                 cur_bits -= 8;
  1381.         }
  1382.  
  1383.         flush_char();
  1384.  
  1385.         fflush( g_outfile );
  1386.  
  1387.     }
  1388. }
  1389.  
  1390. /*
  1391.  * Clear out the hash table
  1392.  */
  1393. static void
  1394. cl_block ()             /* table clear for block compress */
  1395. {
  1396.  
  1397.         cl_hash ( (count_int) hsize );
  1398.         free_ent = ClearCode + 2;
  1399.         clear_flg = 1;
  1400.  
  1401.         output( (code_int)ClearCode );
  1402. }
  1403.  
  1404. static void
  1405. cl_hash(hsize)          /* reset code table */
  1406. register count_int hsize;
  1407. {
  1408.  
  1409.         register count_int *htab_p = htab+hsize;
  1410.  
  1411.         register long i;
  1412.         register long m1 = -1;
  1413.  
  1414.         i = hsize - 16;
  1415.         do {                            /* might use Sys V memset(3) here */
  1416.                 *(htab_p-16) = m1;
  1417.                 *(htab_p-15) = m1;
  1418.                 *(htab_p-14) = m1;
  1419.                 *(htab_p-13) = m1;
  1420.                 *(htab_p-12) = m1;
  1421.                 *(htab_p-11) = m1;
  1422.                 *(htab_p-10) = m1;
  1423.                 *(htab_p-9) = m1;
  1424.                 *(htab_p-8) = m1;
  1425.                 *(htab_p-7) = m1;
  1426.                 *(htab_p-6) = m1;
  1427.                 *(htab_p-5) = m1;
  1428.                 *(htab_p-4) = m1;
  1429.                 *(htab_p-3) = m1;
  1430.                 *(htab_p-2) = m1;
  1431.                 *(htab_p-1) = m1;
  1432.                 htab_p -= 16;
  1433.         } while ((i -= 16) >= 0);
  1434.  
  1435.         for ( i += 16; i > 0; --i )
  1436.                 *--htab_p = m1;
  1437. }
  1438.  
  1439. /******************************************************************************
  1440.  *
  1441.  * GIF Specific routines
  1442.  *
  1443.  ******************************************************************************/
  1444.  
  1445. /*
  1446.  * Number of characters so far in this 'packet'
  1447.  */
  1448. static int a_count;
  1449.  
  1450. /*
  1451.  * Set up the 'byte output' routine
  1452.  */
  1453. static void
  1454. char_init()
  1455. {
  1456.         a_count = 0;
  1457. }
  1458.  
  1459. /*
  1460.  * Define the storage for the packet accumulator
  1461.  */
  1462. static char accum[ 256 ];
  1463.  
  1464. /*
  1465.  * Add a character to the end of the current packet, and if it is 254
  1466.  * characters, flush the packet to disk.
  1467.  */
  1468. static void
  1469. char_out( c )
  1470. int c;
  1471. {
  1472.         accum[ a_count++ ] = c;
  1473.         if( a_count >= 254 )
  1474.                 flush_char();
  1475. }
  1476.  
  1477. /*
  1478.  * Flush the packet to disk, and reset the accumulator
  1479.  */
  1480. static void
  1481. flush_char()
  1482. {
  1483.         if( a_count > 0 ) {
  1484.                 fputc( a_count, g_outfile );
  1485.                 fwrite( accum, 1, a_count, g_outfile );
  1486.                 a_count = 0;
  1487.         }
  1488. }
  1489.  
  1490. /*
  1491. ** Attempt by Jack at re-init
  1492. */
  1493. static void
  1494. GIFcompress_reinit()
  1495. {
  1496.     memset((char *)htab, 0, sizeof(htab));
  1497.     memset((char *)codetab, 0, sizeof(codetab));
  1498.     hsize = HSIZE;
  1499.     free_ent = 0;
  1500.     clear_flg = 0;
  1501.     in_count = 1;
  1502.     out_count = 0;
  1503.  
  1504.     cur_accum = 0;
  1505.     cur_bits = 0;
  1506. }
  1507. /* The End */
  1508.